package com.auto.survey.util.taskqueue

import android.util.Log
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.cancel
import kotlinx.coroutines.launch
import java.util.concurrent.ConcurrentLinkedQueue

import kotlinx.coroutines.*

// 蓝牙任务队列（支持状态监听）
class BluetoothTaskQueue<T> {
    // 任务队列：存储任务及对应的标识
    private val taskQueue = ConcurrentLinkedQueue<Pair<T, BluetoothTask>>()
    private var isProcessing = false

    private var isPaused = false  // 新增：暂停状态标志

    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    // 监听器（默认空实现，避免空指针）
    private var listener: BluetoothTaskListener<T> = object : BluetoothTaskListener<T> {}

    // 设置监听器
    fun setListener(listener: BluetoothTaskListener<T>) {
        this.listener = listener
    }

    /**
     * 添加蓝牙任务到队列（携带任务标识，方便区分）
     * @param taskId 任务唯一标识（如Int、String等）
     * @param task 蓝牙任务
     */
    fun addBluetoothTask(taskId: T, task: BluetoothTask) {
        taskQueue.offer(taskId to task)
        if (!isProcessing && !isPaused) {  // 修改：添加暂停状态检查
            processNextTask()
        }
    }

    // 处理下一个任务（核心逻辑）
    private fun processNextTask() {
        // 如果处于暂停状态，不处理下一个任务
        if (isPaused) {
            Log.i("BluetoothTaskQueue", "队列已暂停，不处理下一个任务")
            return
        }

        val (taskId, currentTask) = taskQueue.poll() ?: run {
            Log.i("BluetoothTaskQueue", "任务队列为空，触发onQueueCompleted")
            // 队列空时主动触发完成回调（原逻辑可能遗漏）
            if (!isProcessing) {
                Log.i ("BluetoothTaskQueue", "任务队列为空且无任务处理，触发 onQueueCompleted")
                scope.launch(Dispatchers.Main) {
                    listener.onQueueCompleted()
                }
            }
            return
        }

        isProcessing = true
        Log.i("BluetoothTaskQueue", "开始处理任务：$taskId")
        // 切换到IO线程执行任务，完成后切回主线程触发监听
        scope.launch {
            // 1. 任务开始：主线程触发onTaskStarted
            withContext(Dispatchers.Main) {
                try {
                    listener.onTaskStarted(taskId)
                    Log.i("BluetoothTaskQueue", "任务开始回调：$taskId")
                } catch (e: Exception) {
                    Log.e("BluetoothTaskQueue", "onTaskStarted回调失败：${e.message}")
                }
            }

            // 2. 执行蓝牙任务（IO线程）
            val result = try {
                Log.i("BluetoothTaskQueue", "执行任务：$taskId")
                currentTask()
            } catch (e: Exception) {
                Log.e("BluetoothTaskQueue", "任务执行异常：${e.message}，任务ID：$taskId", e)
                BluetoothTaskResult.Failure("任务执行异常：${e.message ?: "未知错误"}")
            }


            // 3. 处理任务结果（主线程触发监听）
            withContext(Dispatchers.Main) {
                isProcessing = false
                when (result) {
                    is BluetoothTaskResult.Success -> {
                        // 任务成功：触发onTaskSuccess，继续下一个任务
                        Log.i("BluetoothTaskQueue", "任务成功：$taskId，触发onTaskSuccess")
                        listener.onTaskSuccess(taskId, result.params)

                        // 检查是否还有任务，有则继续，无则触发队列完成
                        // 继续处理下一个任务（若队列非空且未暂停）
                        if (taskQueue.isNotEmpty() && !isPaused) {
                            Log.i("BluetoothTaskQueue", "准备处理下一个任务，剩余：${taskQueue.size}")
                            processNextTask()
                        } else if (taskQueue.isEmpty()) {
                            Log.i("BluetoothTaskQueue", "任务队列已空，触发onQueueCompleted")
                            listener.onQueueCompleted()
                        }
                    }
                    is BluetoothTaskResult.Failure -> {
                        // 任务失败：触发onTaskFailed和队列终止
                        Log.i("BluetoothTaskQueue", "任务失败：$taskId，原因：${result.reason}")
                        listener.onTaskFailed(taskId, result.reason)
                        listener.onQueueAborted(taskId, result.reason)
                    }
                }
            }
        }
    }

    /**
     * 暂停任务队列
     * 当前任务会继续执行，但完成后不会执行下一个任务
     */
    fun pause() {
        if (!isPaused) {
            isPaused = true
            listener.onQueuePaused()
        }
    }

    /**
     * 继续任务队列执行
     */
    fun resume() {
        if (isPaused) {
            isPaused = false
            listener.onQueueResumed()
            // 如果不在处理任务且队列不为空，开始处理下一个任务
            if (!isProcessing && !taskQueue.isEmpty()) {
                processNextTask()
            }
        }
    }

    // 取消所有任务
    fun cancelAll() {
        scope.cancel()
        taskQueue.clear()
        isProcessing = false
        isPaused = false  // 修改：重置暂停状态
    }

    // 待执行任务数量
    fun pendingTaskCount() = taskQueue.size

    // 判断队列是否处于暂停状态
    fun isPaused() = isPaused
}